{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dUeKVCYTbcyT"
      },
      "source": [
        "#### Copyright 2019 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "4ellrPx7tdxq"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7JfLUlawto_D"
      },
      "source": [
        "# 불균형 데이터 분류"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DwdpaTKJOoPu"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://www.tensorflow.org/tutorials/structured_data/imbalanced_data\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />TensorFlow.org에서 보기</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/ko/tutorials/structured_data/imbalanced_data.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Google Colab에서 실행하기</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/tensorflow/docs-l10n/blob/master/site/ko/tutorials/structured_data/imbalanced_data.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />GitHub에서 소스 </a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a href=\"https://storage.googleapis.com/tensorflow_docs/docs-l10n/site/ko/tutorials/structured_data/imbalanced_data.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Download notebook</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mthoSGBAOoX-"
      },
      "source": [
        "이 튜토리얼에서는 한 클래스의 예시의 수가 다른 클래스보다 훨씬 많은 불균형 데이터세트를 분류하는 방법을 소개합니다. Kaggle에서 호스팅 되는 [신용 카드 부정 행위 탐지 데이터세트](https://www.kaggle.com/mlg-ulb/creditcardfraud)를 사용하여 작업할 것입니다. 총 284,807건의 거래에서 492건의 부정거래만 적발하는 것이 목적입니다. [Keras](../../guide/keras/overview.ipynb)를 사용하여 모델 및 [클래스 가중치](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/Model)를 정의하여 불균형 데이터로부터 모델을 학습할 수 있도록 할 것입니다.\n",
        "\n",
        "이 튜토리얼에서는 다음의 완전한 코드가 포함되어있습니다.:\n",
        "\n",
        "* Pandas를 사용하여 CSV 파일 로드.\n",
        "* 학습, 검증 및 테스트세트 작성.\n",
        "* Keras를 사용하여 모델을 정의하고 학습시키기(클래스 가중치 설정 포함).\n",
        "* 다양한 측정 기준(정밀도 및 재현 율 포함)을 사용하여 모델을 평가한다.\n",
        "* 불균형 데이터를 처리하기 위한 다음과 같은 기술을 사용해보십시오:\n",
        "    * 클래스 가중치 \n",
        "    * 오버샘플링\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kRHmSyHxEIhN"
      },
      "source": [
        "## 설정"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JM7hDSNClfoK"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "\n",
        "import os\n",
        "import tempfile\n",
        "\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "\n",
        "import sklearn\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c8o1FHzD-_y_"
      },
      "outputs": [],
      "source": [
        "mpl.rcParams['figure.figsize'] = (12, 10)\n",
        "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z3iZVjziKHmX"
      },
      "source": [
        "## 데이터 처리 및 탐색"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4sA9WOcmzH2D"
      },
      "source": [
        "### Kaggle 신용 카드 부정 행위 데이터 세트 \n",
        "\n",
        "Pandas는 구조화된 데이터를 로드하고 작업하는데 유용한 유틸리티가 많이 있는 Python 라이브러리로서 CSV를 데이터 프레임으로 다운로드 하는데 사용할 수 있다.\n",
        "\n",
        "참고: 이 데이터세트는 큰 데이터 마이닝 및 부정 행위 감지에 대한 Worldline과 ULB의 [Machine Learning Group](http://mlg.ulb.ac.be)  (Université Libre de Bruxelles)의 연구 협업을 통해 수집 및 분석 되었다. 관련 주제에 대한 현재 및 과거의 프로젝트에 대한 자세한 내용은 [여기](https://www.researchgate.net/project/Fraud-detection-5) and the page of the [DefeatFraud](https://mlg.ulb.ac.be/wordpress/portfolio_page/defeatfraud-assessment-and-validation-of-deep-feature-engineering-and-learning-solutions-for-fraud-detection/)에서 확인할 수 있으며 DefeatFraud 프로젝트 페이지도 참조하십시오"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pR_SnbMArXr7"
      },
      "outputs": [],
      "source": [
        "file = tf.keras.utils\n",
        "raw_df = pd.read_csv('https://storage.googleapis.com/download.tensorflow.org/data/creditcard.csv')\n",
        "raw_df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-fgdQgmwUFuj"
      },
      "outputs": [],
      "source": [
        "raw_df[['Time', 'V1', 'V2', 'V3', 'V4', 'V5', 'V26', 'V27', 'V28', 'Amount', 'Class']].describe()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xWKB_CVZFLpB"
      },
      "source": [
        "### 클래스 레이블 불균형 조사\n",
        "\n",
        "데이터세트 불균형을 살펴보겠습니다.:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HCJFrtuY2iLF"
      },
      "outputs": [],
      "source": [
        "neg, pos = np.bincount(raw_df['Class'])\n",
        "total = neg + pos\n",
        "print('Examples:\\n    Total: {}\\n    Positive: {} ({:.2f}% of total)\\n'.format(\n",
        "    total, pos, 100 * pos / total))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KnLKFQDsCBUg"
      },
      "source": [
        "이것은 양성 샘플의 작은 부분을 보여줍니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6qox6ryyzwdr"
      },
      "source": [
        "### 데이터 정리, 분할 및 정규화\n",
        "\n",
        "원시 데이터에는 몇 가지 문제가 있습니다. `Time` 과 `Amount` 열은 너무 가변적이기 때문에 직접적으로 사용할 수 없습니다. 우선 `Time` 열을 삭제한 뒤에 (의미가 명확하지 않아서) `amount` 열의 로그를 가져와서 범위를 줄입니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ef42jTuxEjnj"
      },
      "outputs": [],
      "source": [
        "cleaned_df = raw_df.copy()\n",
        "\n",
        "# You don't want the `Time` column.\n",
        "cleaned_df.pop('Time')\n",
        "\n",
        "# The `Amount` column covers a huge range. Convert to log-space.\n",
        "eps = 0.001 # 0 => 0.1¢\n",
        "cleaned_df['Log Ammount'] = np.log(cleaned_df.pop('Amount')+eps)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uSNgdQFFFQ6u"
      },
      "source": [
        "데이터 세트를 학습, 검증 및 테스트 세트로 분할합니다. 검증 세트는 모델 피팅 중에 손실 및 메트릭을 평가하는 데 사용되지만 모델이 이 데이터에 적합하지 않습니다. 테스트 세트는 훈련 단계에서 완전히 사용되지 않으며 모델이 새 데이터로 얼마나 잘 일반화되는지 평가하기 위해 마지막에만 사용됩니다. 이는 훈련 데이터 부족으로 인하여 [오버피팅](https://developers.google.com/machine-learning/crash-course/generalization/peril-of-overfitting) 이 중요한 문제인 데이터 세트에서 특히 더 중요합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xfxhKg7Yr1-b"
      },
      "outputs": [],
      "source": [
        "# Use a utility from sklearn to split and shuffle our dataset.\n",
        "train_df, test_df = train_test_split(cleaned_df, test_size=0.2)\n",
        "train_df, val_df = train_test_split(train_df, test_size=0.2)\n",
        "\n",
        "# Form np arrays of labels and features.\n",
        "train_labels = np.array(train_df.pop('Class'))\n",
        "bool_train_labels = train_labels != 0\n",
        "val_labels = np.array(val_df.pop('Class'))\n",
        "test_labels = np.array(test_df.pop('Class'))\n",
        "\n",
        "train_features = np.array(train_df)\n",
        "val_features = np.array(val_df)\n",
        "test_features = np.array(test_df)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8a_Z_kBmr7Oh"
      },
      "source": [
        "sklearn StandardScaler를 사용하여 입력 기능을 정규화 합니다.\n",
        "이것은 평균은 0으로, 표준 편차는 1로 설정합니다.\n",
        "\n",
        "참고: StandardScaler는 오직 모델이 validation 또는 test set를 peeking 하지는 않았는지 확인하기 위해 train_feature를 사용할 때 적합합니다. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IO-qEUmJ5JQg"
      },
      "outputs": [],
      "source": [
        "scaler = StandardScaler()\n",
        "train_features = scaler.fit_transform(train_features)\n",
        "\n",
        "val_features = scaler.transform(val_features)\n",
        "test_features = scaler.transform(test_features)\n",
        "\n",
        "train_features = np.clip(train_features, -5, 5)\n",
        "val_features = np.clip(val_features, -5, 5)\n",
        "test_features = np.clip(test_features, -5, 5)\n",
        "\n",
        "\n",
        "print('Training labels shape:', train_labels.shape)\n",
        "print('Validation labels shape:', val_labels.shape)\n",
        "print('Test labels shape:', test_labels.shape)\n",
        "\n",
        "print('Training features shape:', train_features.shape)\n",
        "print('Validation features shape:', val_features.shape)\n",
        "print('Test features shape:', test_features.shape)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XF2nNfWKJ33w"
      },
      "source": [
        "주의: 모델을 배포하려면 전처리 계산을 유지하는 것이 중요합니다. 레이어로 구현하고 내보내기 전에 모델에 연결하는 것이 가장 쉬운 방법입니다.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uQ7m9nqDC3W6"
      },
      "source": [
        "### 데이터 분포 살펴보기 \n",
        "\n",
        "다음으로 몇 가지 기능에 대한 긍정 및 부정 예제의 분포를 비교하십시오. 이 때 스스로에게 물어볼 좋은 질문은 다음과 같습니다.:\n",
        "\n",
        "* 이러한 분포가 의미가 있습니까?\n",
        "    * 예. 이미 입력을 정규화했으며 대부분 `+/- 2` 범위에 밀집되어 있습니다.\n",
        "* 분포의 차이를 볼 수 있습니까?\n",
        "    * 예. 긍정적인 예는 그렇지 않은 것 보다 훨씬 더 높은 극단적인 값을 포함합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "raK7hyjd_vf6"
      },
      "outputs": [],
      "source": [
        "pos_df = pd.DataFrame(train_features[ bool_train_labels], columns=train_df.columns)\n",
        "neg_df = pd.DataFrame(train_features[~bool_train_labels], columns=train_df.columns)\n",
        "\n",
        "sns.jointplot(pos_df['V5'], pos_df['V6'],\n",
        "              kind='hex', xlim=(-5,5), ylim=(-5,5))\n",
        "plt.suptitle(\"Positive distribution\")\n",
        "\n",
        "sns.jointplot(neg_df['V5'], neg_df['V6'],\n",
        "              kind='hex', xlim=(-5,5), ylim=(-5,5))\n",
        "_ = plt.suptitle(\"Negative distribution\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qFK1u4JX16D8"
      },
      "source": [
        "## 모델 및 메트릭 정의\n",
        "\n",
        "촘촘하게 연결된 히든 레이어, 과적합을 줄이기 위한 [drop out](https://developers.google.com/machine-learning/glossary/#dropout_regularization) 레이어, 거래 사기 가능성을 반환하는 출력 sigmoid 레이어로 간단한 신경망을 생성하는 함수를 정의합니다. : "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3JQDzUqT3UYG"
      },
      "outputs": [],
      "source": [
        "METRICS = [\n",
        "      keras.metrics.TruePositives(name='tp'),\n",
        "      keras.metrics.FalsePositives(name='fp'),\n",
        "      keras.metrics.TrueNegatives(name='tn'),\n",
        "      keras.metrics.FalseNegatives(name='fn'), \n",
        "      keras.metrics.BinaryAccuracy(name='accuracy'),\n",
        "      keras.metrics.Precision(name='precision'),\n",
        "      keras.metrics.Recall(name='recall'),\n",
        "      keras.metrics.AUC(name='auc'),\n",
        "]\n",
        "\n",
        "def make_model(metrics=METRICS, output_bias=None):\n",
        "  if output_bias is not None:\n",
        "    output_bias = tf.keras.initializers.Constant(output_bias)\n",
        "  model = keras.Sequential([\n",
        "      keras.layers.Dense(\n",
        "          16, activation='relu',\n",
        "          input_shape=(train_features.shape[-1],)),\n",
        "      keras.layers.Dropout(0.5),\n",
        "      keras.layers.Dense(1, activation='sigmoid',\n",
        "                         bias_initializer=output_bias),\n",
        "  ])\n",
        "\n",
        "  model.compile(\n",
        "      optimizer=keras.optimizers.Adam(lr=1e-3),\n",
        "      loss=keras.losses.BinaryCrossentropy(),\n",
        "      metrics=metrics)\n",
        "\n",
        "  return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SU0GX6E6mieP"
      },
      "source": [
        "### 유용한 메트릭 이해\n",
        "\n",
        "위에서 정의한 몇 가지 지표는 성능을 평가할 때 도움이 될 모델에 의해 계산될 수 있다는 점에 유의하십시오. \n",
        "\n",
        "\n",
        "\n",
        "*   **거짓** 음성 그리고 **거짓** 양성은 **잘못** 분류된 샘플입니다.\n",
        "*   **참** 음성 그리고 **참** 양성은 **제대로** 분류된 샘플입니다.\n",
        "*   **정확도** 는 올바르게 분류된 예제의 비율입니다.\n",
        ">   $\\frac{\\text{true samples}}{\\text{total samples}}$\n",
        "*   **정밀도** 는 올바르게 분류된 **예측** 긍정 비율입니다.\n",
        ">   $\\frac{\\text{true positives}}{\\text{true positives + false positives}}$\n",
        "*   **재현 율** 은 올바르게 분류된 **실제** 긍정 비율입니다.\n",
        ">   $\\frac{\\text{true positives}}{\\text{true positives + false negatives}}$\n",
        "*   **AUC** 는 수신자 조작 특성 곡선 아래 영역(ROC-AUC)을 나타냅니다. 이 메트릭은 분류기가 무작위 음성 샘플보다 무작위 양성 샘플의 순위를 매길 확률과 동일합니다. \n",
        "\n",
        "참고: 정확도는 이 작업에 유용한 측정 항목이 아닙니다. 항상 False를 예측해야 이 작업에서 99.8% 이상의 정확도를 얻을 수 있습니다.  \n",
        "\n",
        "Read more:\n",
        "*  [참 vs. 거짓 and 긍정 vs. 부정](https://developers.google.com/machine-learning/crash-course/classification/true-false-positive-negative)\n",
        "*  [정확성](https://developers.google.com/machine-learning/crash-course/classification/accuracy)\n",
        "*   [정밀도와 재현율](https://developers.google.com/machine-learning/crash-course/classification/precision-and-recall)\n",
        "*   [ROC-AUC](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FYdhSAoaF_TK"
      },
      "source": [
        "## 기준 모델"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IDbltVPg2m2q"
      },
      "source": [
        "### 모델 구축\n",
        "\n",
        "이제 이전에 정의한 함수를 통해서 모델을 만들고 학습시키십시오. 모델의 크기가 기본 배치 크기인 2048보다 큰 배치 크기를 사용하여야 적합한 것을 유의하십시오. 이는 각 배치에서 몇 개의 양성 샘플을 포함할 수 있는 적절한 기회를 확보하는데 있어서 중요하다. \n",
        "\n",
        "\n",
        "참고: 이 모델은 클래스의 불균형을 잘 다루지 못합니다. 이를 이 튜토리얼의 뒷부분에서 개선하게 될 겁니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ouUkwPcGQsy3"
      },
      "outputs": [],
      "source": [
        "EPOCHS = 100\n",
        "BATCH_SIZE = 2048\n",
        "\n",
        "early_stopping = tf.keras.callbacks.EarlyStopping(\n",
        "    monitor='val_auc', \n",
        "    verbose=1,\n",
        "    patience=10,\n",
        "    mode='max',\n",
        "    restore_best_weights=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1xlR_dekzw7C"
      },
      "outputs": [],
      "source": [
        "model = make_model()\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wx7ND3_SqckO"
      },
      "source": [
        "Test run the model:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LopSd-yQqO3a"
      },
      "outputs": [],
      "source": [
        "model.predict(train_features[:10])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YKIgWqHms_03"
      },
      "source": [
        "### 선택사항: 올바른 초기 바이어스를 설정합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qk_3Ry6EoYDq"
      },
      "source": [
        "이러한 초기 추측은 좋지 못합니다. 데이터 세트가 불균형 하다는 것을 알고 있습니다. 그렇다면 이를 반영하도록 출력 계층의 바이어스를 설정합니다. (참조: [신경망 훈련을 위한 레시피: \"init well\"](http://karpathy.github.io/2019/04/25/recipe/#2-set-up-the-end-to-end-trainingevaluation-skeleton--get-dumb-baselines)). 이것은 초기 수렴에 도움이 될 수 있습니다. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PdbfWDuVpo6k"
      },
      "source": [
        "기본 바이어스 초기화를 사용하면 손실은 약 `math.log(2) = 0.69314` "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H-oPqh3SoGXk"
      },
      "outputs": [],
      "source": [
        "results = model.evaluate(train_features, train_labels, batch_size=BATCH_SIZE, verbose=0)\n",
        "print(\"Loss: {:0.4f}\".format(results[0]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hE-JRzfKqfhB"
      },
      "source": [
        "설정할 올바른 바이어스는 다음에서 파생 가능합니다.:\n",
        "\n",
        "$$ p_0 = pos/(pos + neg) = 1/(1+e^{-b_0}) $$\n",
        "$$ b_0 = -log_e(1/p_0 - 1) $$\n",
        "$$ b_0 = log_e(pos/neg)$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "F5KWPSjjstUS"
      },
      "outputs": [],
      "source": [
        "initial_bias = np.log([pos/neg])\n",
        "initial_bias"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d1juXI9yY1KD"
      },
      "source": [
        "이를 초기 바이어스로 설정하면 모델이 훨씬 더 합리적인 초기 추측을 제공합니다. \n",
        "\n",
        "가까워 야합니다.: `pos/total = 0.0018`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "50oyu1uss0i-"
      },
      "outputs": [],
      "source": [
        "model = make_model(output_bias=initial_bias)\n",
        "model.predict(train_features[:10])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4xqFYb2KqRHQ"
      },
      "source": [
        "이 초기화를 통해서 초기 손실은 대략 다음과 같아야합니다.:\n",
        "\n",
        "$$-p_0log(p_0)-(1-p_0)log(1-p_0) = 0.01317$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xVDqCWXDqHSc"
      },
      "outputs": [],
      "source": [
        "results = model.evaluate(train_features, train_labels, batch_size=BATCH_SIZE, verbose=0)\n",
        "print(\"Loss: {:0.4f}\".format(results[0]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FrDC8hvNr9yw"
      },
      "source": [
        "이 초기 손실은 단순한 상태의 초기화에서 발생했을 때 보다 약 50배 적습니다.\n",
        "\n",
        "이런 식으로 모델은 긍정적인 예시의 가능성이 낮다는 것을 배우면서 처음 몇 epoch를 보낼 필요는 없습니다. 이것은 또한 훈련 중 plot의 손실을 더 쉽게 읽어낼 수 있게 해줍니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0EJj9ixKVBMT"
      },
      "source": [
        "### 초기 가중치 체크 포인트\n",
        "\n",
        "다양한 훈련 실행을 더욱 비교 가능하도록 하고 싶다면 초기 모델의 가중치를 체크 포인트 파일에 보관하고 훈련 전에 각 모델에 로드 하십시오 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_tSUm4yAVIif"
      },
      "outputs": [],
      "source": [
        "initial_weights = os.path.join(tempfile.mkdtemp(), 'initial_weights')\n",
        "model.save_weights(initial_weights)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EVXiLyqyZ8AX"
      },
      "source": [
        "### 바이어스 수정이 도움이 되는지 확인\n",
        "\n",
        "계속 진행하기 전에 조심스러운 바이어스 초기화가 실제로 도움이 되었는지 빠르게 확인하십시오\n",
        "\n",
        "조심스럽게 초기화를 한 것과 사용하지 않은 것의 20 epoch 동안 모델을 훈련하고 손실을 비교합니다.: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Dm4-4K5RZ63Q"
      },
      "outputs": [],
      "source": [
        "model = make_model()\n",
        "model.load_weights(initial_weights)\n",
        "model.layers[-1].bias.assign([0.0])\n",
        "zero_bias_history = model.fit(\n",
        "    train_features,\n",
        "    train_labels,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    epochs=20,\n",
        "    validation_data=(val_features, val_labels), \n",
        "    verbose=0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j8DsLXHQaSql"
      },
      "outputs": [],
      "source": [
        "model = make_model()\n",
        "model.load_weights(initial_weights)\n",
        "careful_bias_history = model.fit(\n",
        "    train_features,\n",
        "    train_labels,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    epochs=20,\n",
        "    validation_data=(val_features, val_labels), \n",
        "    verbose=0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E3XsMBjhauFV"
      },
      "outputs": [],
      "source": [
        "def plot_loss(history, label, n):\n",
        "  # Use a log scale to show the wide range of values.\n",
        "  plt.semilogy(history.epoch, history.history['loss'],\n",
        "               color=colors[n], label='Train '+label)\n",
        "  plt.semilogy(history.epoch, history.history['val_loss'],\n",
        "          color=colors[n], label='Val '+label,\n",
        "          linestyle=\"--\")\n",
        "  plt.xlabel('Epoch')\n",
        "  plt.ylabel('Loss')\n",
        "  \n",
        "  plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dxFaskm7beC7"
      },
      "outputs": [],
      "source": [
        "plot_loss(zero_bias_history, \"Zero Bias\", 0)\n",
        "plot_loss(careful_bias_history, \"Careful Bias\", 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fKMioV0ddG3R"
      },
      "source": [
        "위의 그림은 이를 명확하게 보여줍니다. 유효성 검사 손실 측면에서 이 문제에 대해 조심스러운 초기화는 명확한 이점을 제공합니다. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RsA_7SEntRaV"
      },
      "source": [
        "### 모델 훈련"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yZKAc8NCDnoR"
      },
      "outputs": [],
      "source": [
        "model = make_model()\n",
        "model.load_weights(initial_weights)\n",
        "baseline_history = model.fit(\n",
        "    train_features,\n",
        "    train_labels,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    epochs=EPOCHS,\n",
        "    callbacks=[early_stopping],\n",
        "    validation_data=(val_features, val_labels))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iSaDBYU9xtP6"
      },
      "source": [
        "### 학습 이력 확인\n",
        "이 섹션에서는 훈련 및 검증 세트에 대한 모델의 정확도와 손실에 대한 plot을 생성합니다. 이는 과적합을 확인하는데 유용하며 이 [튜토리얼](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit)에서 자세한 내용을 확인할 수 있습니다.\n",
        "\n",
        "추가적으로, 위에서 만든 모든 메트릭에 대해 이러한 plot을 생성할 수 있습니다. 거짓 음성이 포함되는 경우가 예시입니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WTSkhT1jyGu6"
      },
      "outputs": [],
      "source": [
        "def plot_metrics(history):\n",
        "  metrics = ['loss', 'auc', 'precision', 'recall']\n",
        "  for n, metric in enumerate(metrics):\n",
        "    name = metric.replace(\"_\",\" \").capitalize()\n",
        "    plt.subplot(2,2,n+1)\n",
        "    plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')\n",
        "    plt.plot(history.epoch, history.history['val_'+metric],\n",
        "             color=colors[0], linestyle=\"--\", label='Val')\n",
        "    plt.xlabel('Epoch')\n",
        "    plt.ylabel(name)\n",
        "    if metric == 'loss':\n",
        "      plt.ylim([0, plt.ylim()[1]])\n",
        "    elif metric == 'auc':\n",
        "      plt.ylim([0.8,1])\n",
        "    else:\n",
        "      plt.ylim([0,1])\n",
        "\n",
        "    plt.legend()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u6LReDsqlZlk"
      },
      "outputs": [],
      "source": [
        "plot_metrics(baseline_history)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UCa4iWo6WDKR"
      },
      "source": [
        "참고: 검증 곡선은 일반적으로 훈련 곡선보다 성능이 좋습니다. 이는 주로 모델을 평가할 때 drop out 레이어가 활성화 되지 않았기 때문에 발생합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aJC1booryouo"
      },
      "source": [
        "### 메트릭 평가\n",
        "\n",
        "[혼동 행렬](https://developers.google.com/machine-learning/glossary/#confusion_matrix) 을 사용하여 X축이 예측 레이블이고 Y축이 실제 레이블인 실제 레이블과 예측 레이블을 요약할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aNS796IJKrev"
      },
      "outputs": [],
      "source": [
        "train_predictions_baseline = model.predict(train_features, batch_size=BATCH_SIZE)\n",
        "test_predictions_baseline = model.predict(test_features, batch_size=BATCH_SIZE)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MVWBGfADwbWI"
      },
      "outputs": [],
      "source": [
        "def plot_cm(labels, predictions, p=0.5):\n",
        "  cm = confusion_matrix(labels, predictions > p)\n",
        "  plt.figure(figsize=(5,5))\n",
        "  sns.heatmap(cm, annot=True, fmt=\"d\")\n",
        "  plt.title('Confusion matrix @{:.2f}'.format(p))\n",
        "  plt.ylabel('Actual label')\n",
        "  plt.xlabel('Predicted label')\n",
        "\n",
        "  print('Legitimate Transactions Detected (True Negatives): ', cm[0][0])\n",
        "  print('Legitimate Transactions Incorrectly Detected (False Positives): ', cm[0][1])\n",
        "  print('Fraudulent Transactions Missed (False Negatives): ', cm[1][0])\n",
        "  print('Fraudulent Transactions Detected (True Positives): ', cm[1][1])\n",
        "  print('Total Fraudulent Transactions: ', np.sum(cm[1]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nOTjD5Z5Wp1U"
      },
      "source": [
        "테스트 데이터 세트에서 모델을 평가하고 위에서 만든 측정 항목의 결과를 표시합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "poh_hZngt2_9"
      },
      "outputs": [],
      "source": [
        "baseline_results = model.evaluate(test_features, test_labels,\n",
        "                                  batch_size=BATCH_SIZE, verbose=0)\n",
        "for name, value in zip(model.metrics_names, baseline_results):\n",
        "  print(name, ': ', value)\n",
        "print()\n",
        "\n",
        "plot_cm(test_labels, test_predictions_baseline)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PyZtSr1v6L4t"
      },
      "source": [
        "만약 모델이 모든 것을 완벽하게 예측했다면 이것은 잘못된 예측을 나타내는 주 대각선의 값이 0이 되는 [대각행렬](https://en.wikipedia.org/wiki/Diagonal_matrix) 이 됩니다. 이러한 경우에 매트릭스가 잘못 탐지한 경우가 상대적으로 적다는 것을 보여줍니다. 즉 잘못 플래그가 지정된 합법적인 거래가 상대적으로 적은 것을 의미합니다. 그러나 거짓 양성 수를 늘릴 때 드는 비용에도 불구하고 더 적은 수의 거짓 음성을 원할 수 있습니다. 거짓 음성 판정이 부정 거래를 통과할 수 있는 반면, 거짓 긍정 판정이 고객에게 이메일을 보내 카드 활동을 확인하도록 요청할 수 있기 때문에 이러한 거래 중단이 더 바람 직 할 수 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P-QpQsip_F2Q"
      },
      "source": [
        "### ROC 플로팅\n",
        "\n",
        "이제 [ROC](https://developers.google.com/machine-learning/glossary#ROC)을 플로팅 하십시오. 이 그래프는 출력 임계값을 조정하기만 해도 모델이 도달할 수 있는 성능 범위를 한눈에 보여주기 때문에 유용합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lhaxsLSvANF9"
      },
      "outputs": [],
      "source": [
        "def plot_roc(name, labels, predictions, **kwargs):\n",
        "  fp, tp, _ = sklearn.metrics.roc_curve(labels, predictions)\n",
        "\n",
        "  plt.plot(100*fp, 100*tp, label=name, linewidth=2, **kwargs)\n",
        "  plt.xlabel('False positives [%]')\n",
        "  plt.ylabel('True positives [%]')\n",
        "  plt.xlim([-0.5,20])\n",
        "  plt.ylim([80,100.5])\n",
        "  plt.grid(True)\n",
        "  ax = plt.gca()\n",
        "  ax.set_aspect('equal')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DfHHspttKJE0"
      },
      "outputs": [],
      "source": [
        "plot_roc(\"Train Baseline\", train_labels, train_predictions_baseline, color=colors[0])\n",
        "plot_roc(\"Test Baseline\", test_labels, test_predictions_baseline, color=colors[0], linestyle='--')\n",
        "plt.legend(loc='lower right')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gpdsFyp64DhY"
      },
      "source": [
        "비교적 정밀도가 높은 것 같지만 회수율과 ROC 곡선(AUC) 밑 면적이 마음에 들 만큼 높지 않습니다. 분류자는 정밀도와 리콜을 모두 최대화 하려고 할 때 종종 도전해야 할 문제에 직면하는데, 이는 불균형 데이터세트로 작업할 떄 특히 그러합니다. 당신이 신경쓰는 문제의 맥락에서 다른 유형의 오류의 비용을 고려하는 것이 중요합니다. 이 예시에서 거짓음성(부정 거래를 놓친 경우)은 금전적인 비용을 초래하지만 , 거짓 양성(거래가 사기 행위로 잘못 표시됨)은 사용자들의 만족도를 감소시킬 수 있습니다. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cveQoiMyGQCo"
      },
      "source": [
        "## 클래스 가중치"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ePGp6GUE1WfH"
      },
      "source": [
        "### 클래스 가중치 계산\n",
        "\n",
        "목표는 부정 거래를 식별하는 것이지만, 여러분은 작업할 수 있는 긍정적인 샘플이 많지 않기 깨문에 분류자가 이용할 수 있는 몇 가지 예에 가중치를 두고자 할 것입니다. 매개 변수를 통해 각 클래스에 대한 Keras 가중치를 전달한다면 이 과정을 할 수 있습니다. 이로 인해 모델이 덜 표현된 클래스의 예에 \"더 많은 주의를 기울이십시오\"라고 할 수도 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qjGWErngGny7"
      },
      "outputs": [],
      "source": [
        "# Scaling by total/2 helps keep the loss to a similar magnitude.\n",
        "# The sum of the weights of all examples stays the same.\n",
        "weight_for_0 = (1 / neg)*(total)/2.0 \n",
        "weight_for_1 = (1 / pos)*(total)/2.0\n",
        "\n",
        "class_weight = {0: weight_for_0, 1: weight_for_1}\n",
        "\n",
        "print('Weight for class 0: {:.2f}'.format(weight_for_0))\n",
        "print('Weight for class 1: {:.2f}'.format(weight_for_1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mk1OOE2ZSHzy"
      },
      "source": [
        "### 클래스 가중치로 모델 교육\n",
        "\n",
        "이제 해당 모델이 예측에 어떤 영향을 미치는지 확인하기 위하여 클래스 가중치로 모델을 재 교육하고 평가해 보십시오.\n",
        "\n",
        "참고: `class_weights` 를 사용하면 손실 범위가 바뀝니다. 이는 최적기에 따라 학습의 안정성에 영향을 미칠 수 있습니다. 단계 크기가 그라데이션의 크기에 따라 달라지는 `optimizers.SGD` 와 같은 최적화 도구는 실패할 수 있습니다. 여기서 사용되는 최적화기인 `optimizers.Adam` 은 스케일링 변화에 영향을 받지 않습니다. 또한 가중치 때문에 전체 손실은 두 모델 간에 비교할 수 없습니다. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UJ589fn8ST3x"
      },
      "outputs": [],
      "source": [
        "weighted_model = make_model()\n",
        "weighted_model.load_weights(initial_weights)\n",
        "\n",
        "weighted_history = weighted_model.fit(\n",
        "    train_features,\n",
        "    train_labels,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    epochs=EPOCHS,\n",
        "    callbacks=[early_stopping],\n",
        "    validation_data=(val_features, val_labels),\n",
        "    # The class weights go here\n",
        "    class_weight=class_weight) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R0ynYRO0G3Lx"
      },
      "source": [
        "### 학습 이력 조회"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BBe9FMO5ucTC"
      },
      "outputs": [],
      "source": [
        "plot_metrics(weighted_history)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "REy6WClTZIwQ"
      },
      "source": [
        "### 매트릭 평가"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nifqscPGw-5w"
      },
      "outputs": [],
      "source": [
        "train_predictions_weighted = weighted_model.predict(train_features, batch_size=BATCH_SIZE)\n",
        "test_predictions_weighted = weighted_model.predict(test_features, batch_size=BATCH_SIZE)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "owKL2vdMBJr6"
      },
      "outputs": [],
      "source": [
        "weighted_results = weighted_model.evaluate(test_features, test_labels,\n",
        "                                           batch_size=BATCH_SIZE, verbose=0)\n",
        "for name, value in zip(weighted_model.metrics_names, weighted_results):\n",
        "  print(name, ': ', value)\n",
        "print()\n",
        "\n",
        "plot_cm(test_labels, test_predictions_weighted)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PTh1rtDn8r4-"
      },
      "source": [
        "여기서 클래스 가중치를 사용하면 거짓 긍정이 더 많기 때문에 정확도와 정밀도가 낮다는 것을 알 수 있지만, 반대로 리콜과 AUC는 참 긍정이 더 많은 모델입니다. 정확도가 낮음에도 불구하고 이 모델은 리콜이 더 높습니다.(그리고 더 많은 부정 거래를 식별한다.) 물론 두 가지 유형의 오류에는 모두 비용이 발생합니다.(너무 많은 합법적인 거래를 사기로 표시하여 사용자를 괴롭히는 것을 원하지 않을 것입니다.) 응용 프로그램에 대하여 이러한 다양한 유형의 오류 간의 절충을 신중하게 고려하십시오."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hXDAwyr0HYdX"
      },
      "source": [
        "### ROC 플로팅"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3hzScIVZS1Xm"
      },
      "outputs": [],
      "source": [
        "plot_roc(\"Train Baseline\", train_labels, train_predictions_baseline, color=colors[0])\n",
        "plot_roc(\"Test Baseline\", test_labels, test_predictions_baseline, color=colors[0], linestyle='--')\n",
        "\n",
        "plot_roc(\"Train Weighted\", train_labels, train_predictions_weighted, color=colors[1])\n",
        "plot_roc(\"Test Weighted\", test_labels, test_predictions_weighted, color=colors[1], linestyle='--')\n",
        "\n",
        "\n",
        "plt.legend(loc='lower right')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ysRtr6xHnXP"
      },
      "source": [
        "## 오버샘플링"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "18VUHNc-UF5w"
      },
      "source": [
        "### 소수 계급 과대 표본\n",
        "\n",
        "관련된 접근 방식은 소수 클래스를 오버 샘플링 하여 데이터 세트를 리 샘플링 하는 것입니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sHirNp6u7OWp"
      },
      "outputs": [],
      "source": [
        "pos_features = train_features[bool_train_labels]\n",
        "neg_features = train_features[~bool_train_labels]\n",
        "\n",
        "pos_labels = train_labels[bool_train_labels]\n",
        "neg_labels = train_labels[~bool_train_labels]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WgBVbX7P7QrL"
      },
      "source": [
        "#### NumPy 사용\n",
        "\n",
        "긍정적인 예에서 적절한 수의 임의 인덱스를 선택하여 데이터 세트의 균형을 \n",
        "수동으로 조정할 수 있습니다.:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BUzGjSkwqT88"
      },
      "outputs": [],
      "source": [
        "ids = np.arange(len(pos_features))\n",
        "choices = np.random.choice(ids, len(neg_features))\n",
        "\n",
        "res_pos_features = pos_features[choices]\n",
        "res_pos_labels = pos_labels[choices]\n",
        "\n",
        "res_pos_features.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7ie_FFet6cep"
      },
      "outputs": [],
      "source": [
        "resampled_features = np.concatenate([res_pos_features, neg_features], axis=0)\n",
        "resampled_labels = np.concatenate([res_pos_labels, neg_labels], axis=0)\n",
        "\n",
        "order = np.arange(len(resampled_labels))\n",
        "np.random.shuffle(order)\n",
        "resampled_features = resampled_features[order]\n",
        "resampled_labels = resampled_labels[order]\n",
        "\n",
        "resampled_features.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IYfJe2Kc-FAz"
      },
      "source": [
        "#### `tf.data` 사용"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "usyixaST8v5P"
      },
      "source": [
        "`tf.data` 사용하는 경우 균형 잡힌 예제를 생성하는 가장 쉬운 방법은 `positive` 그리고 `negative` 데이터 세트로 시작하여 병합하는 것입니다. 더 많은 예는 [tf.data guide](../../guide/data.ipynb) 를 참조하세요."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yF4OZ-rI6xb6"
      },
      "outputs": [],
      "source": [
        "BUFFER_SIZE = 100000\n",
        "\n",
        "def make_ds(features, labels):\n",
        "  ds = tf.data.Dataset.from_tensor_slices((features, labels))#.cache()\n",
        "  ds = ds.shuffle(BUFFER_SIZE).repeat()\n",
        "  return ds\n",
        "\n",
        "pos_ds = make_ds(pos_features, pos_labels)\n",
        "neg_ds = make_ds(neg_features, neg_labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNQUx-OA-oJc"
      },
      "source": [
        "각 데이터 세트는 `(feature, label)` 쌍을 제공합니다.:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "llXc9rNH7Fbz"
      },
      "outputs": [],
      "source": [
        "for features, label in pos_ds.take(1):\n",
        "  print(\"Features:\\n\", features.numpy())\n",
        "  print()\n",
        "  print(\"Label: \", label.numpy())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sLEfjZO0-vbN"
      },
      "source": [
        "`experimental.sample_from_datasets` 를 사용하여 두 가지를 병합합니다.:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e7w9UQPT9wzE"
      },
      "outputs": [],
      "source": [
        "resampled_ds = tf.data.experimental.sample_from_datasets([pos_ds, neg_ds], weights=[0.5, 0.5])\n",
        "resampled_ds = resampled_ds.batch(BATCH_SIZE).prefetch(2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EWXARdTdAuQK"
      },
      "outputs": [],
      "source": [
        "for features, label in resampled_ds.take(1):\n",
        "  print(label.numpy().mean())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "irgqf3YxAyN0"
      },
      "source": [
        "이 데이터 세트를 사용하려면 epoch 당 단계 수가 필요합니다.\n",
        "\n",
        "이 경우 \"epoch\" 의 정의는 명확하지 않습니다. 각 부정적인 예를 한번 볼 때 필요한 배치 수라고 가정합니다.:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xH-7K46AAxpq"
      },
      "outputs": [],
      "source": [
        "resampled_steps_per_epoch = np.ceil(2.0*neg/BATCH_SIZE)\n",
        "resampled_steps_per_epoch"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XZ1BvEpcBVHP"
      },
      "source": [
        "### 오버 샘플링 된 데이터에 대한 학습\n",
        "\n",
        "이제 클래스 가중치를 사용하는 대신 리 샘플링 된 데이터 세트로 모델을 학습하여 이러한 방법이 어떻게 비교되는지 확인하십시오.\n",
        "\n",
        "참고: 긍정적인 예를 복제하여 데이터가 균형을 이루었기 때문에 총 데이터 세트 크기가 더 크고 각 세대가 더 많은 학습 단계를 위해 실행됩니다. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "soRQ89JYqd6b"
      },
      "outputs": [],
      "source": [
        "resampled_model = make_model()\n",
        "resampled_model.load_weights(initial_weights)\n",
        "\n",
        "# Reset the bias to zero, since this dataset is balanced.\n",
        "output_layer = resampled_model.layers[-1] \n",
        "output_layer.bias.assign([0])\n",
        "\n",
        "val_ds = tf.data.Dataset.from_tensor_slices((val_features, val_labels)).cache()\n",
        "val_ds = val_ds.batch(BATCH_SIZE).prefetch(2) \n",
        "\n",
        "resampled_history = resampled_model.fit(\n",
        "    resampled_ds,\n",
        "    epochs=EPOCHS,\n",
        "    steps_per_epoch=resampled_steps_per_epoch,\n",
        "    callbacks=[early_stopping],\n",
        "    validation_data=val_ds)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "avALvzUp3T_c"
      },
      "source": [
        "만약 훈련 프로세스가 각 기울기 업데이트에서 전체 데이터 세트를 고려하는 경우, 이 오버 샘플링은 기본적으로 클래스 가중치와 동일합니다. \n",
        "\n",
        "그러나 여기에서 한 것처럼 모델을 배치 방식으로 훈련 할 때 오버 샘플링 된 데이터는 더 부드러운 기울기 신호를 제공합니다. 각각의 긍정적인 예가 큰 가중치를 가진 하나의 배치로 표시되는 대신, 그것들은 작은 가중치로 매 회 많은 다른 배치로 보여집니다. \n",
        "\n",
        "이 부드러운 기울기 신호는 모델을 더 쉽게 훈련 할 수 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "klHZ0HV76VC5"
      },
      "source": [
        "### 교육 이력 확인\n",
        "\n",
        "학습 데이터의 분포가 검증 및 테스트 데이터와 완전히 다르기 때문에 여기서 측정 항목의 분포가 다를 수 있습니다. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YoUGfr1vuivl"
      },
      "outputs": [],
      "source": [
        "plot_metrics(resampled_history)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1PuH3A2vnwrh"
      },
      "source": [
        "### 재교육\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KFLxRL8eoDE5"
      },
      "source": [
        "균형 잡힌 데이터에 대한 훈련이 더 쉽기 때문에 위의 훈련 절차가 빠르게 과적합 될 수 있습니다. \n",
        "\n",
        "따라서 epochs를 분리하여 `callbacks.EarlyStopping`을 제공하십시오. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e_yn9I26qAHU"
      },
      "outputs": [],
      "source": [
        "resampled_model = make_model()\n",
        "resampled_model.load_weights(initial_weights)\n",
        "\n",
        "# Reset the bias to zero, since this dataset is balanced.\n",
        "output_layer = resampled_model.layers[-1] \n",
        "output_layer.bias.assign([0])\n",
        "\n",
        "resampled_history = resampled_model.fit(\n",
        "    resampled_ds,\n",
        "    # These are not real epochs\n",
        "    steps_per_epoch=20,\n",
        "    epochs=10*EPOCHS,\n",
        "    callbacks=[early_stopping],\n",
        "    validation_data=(val_ds))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UuJYKv0gpBK1"
      },
      "source": [
        "### 훈련 이력 재확인"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FMycrpJwn39w"
      },
      "outputs": [],
      "source": [
        "plot_metrics(resampled_history)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bUuE5HOWZiwP"
      },
      "source": [
        "### 메트릭 평가"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "C0fmHSgXxFdW"
      },
      "outputs": [],
      "source": [
        "train_predictions_resampled = resampled_model.predict(train_features, batch_size=BATCH_SIZE)\n",
        "test_predictions_resampled = resampled_model.predict(test_features, batch_size=BATCH_SIZE)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FO0mMOYUDWFk"
      },
      "outputs": [],
      "source": [
        "resampled_results = resampled_model.evaluate(test_features, test_labels,\n",
        "                                             batch_size=BATCH_SIZE, verbose=0)\n",
        "for name, value in zip(resampled_model.metrics_names, resampled_results):\n",
        "  print(name, ': ', value)\n",
        "print()\n",
        "\n",
        "plot_cm(test_labels, test_predictions_resampled)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_xYozM1IIITq"
      },
      "source": [
        "### ROC 플로팅"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fye_CiuYrZ1U"
      },
      "outputs": [],
      "source": [
        "plot_roc(\"Train Baseline\", train_labels, train_predictions_baseline, color=colors[0])\n",
        "plot_roc(\"Test Baseline\", test_labels, test_predictions_baseline, color=colors[0], linestyle='--')\n",
        "\n",
        "plot_roc(\"Train Weighted\", train_labels, train_predictions_weighted, color=colors[1])\n",
        "plot_roc(\"Test Weighted\", test_labels, test_predictions_weighted, color=colors[1], linestyle='--')\n",
        "\n",
        "plot_roc(\"Train Resampled\", train_labels, train_predictions_resampled, color=colors[2])\n",
        "plot_roc(\"Test Resampled\", test_labels, test_predictions_resampled, color=colors[2], linestyle='--')\n",
        "plt.legend(loc='lower right')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3o3f0ywl8uqW"
      },
      "source": [
        "## 튜토리얼을 이 문제에 적용\n",
        "\n",
        "불균형 데이터 분류는 학습 할 샘플이 너무 적기 때문에 본질적으로 어려운 작업입니다. 항상 데이터부터 시작하여 가능한 한 많은 샘플을 수집하고 모델이 소수 클래스를 최대한 활용할 수 있도록 어떤 기능이 관련 될 수 있는지에 대해 실질적인 생각을 하도록 최선을 다해야 합니다. 어떤 시점에서 모델은 원하는 결과를 개선하고 산출하는데 어려움을 겪을 수 있으므로 문제의 컨텍스트와 다양한 유형의 오류 간의 균형을 염두에 두는 것이 중요합니다. "
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "imbalanced_data.ipynb",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
